package org.winthedocs.processor;

import org.winthedocs.common.Utils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;

/**
 * 对比英文文件，并更新翻译文档
 */
public class ProcessDocs {

    /**
     * 根据英文文档的更新把更新的英文内容追加到翻译文档中
     * @param srcPath 原英文文档
     * @param dstPath 更新的英文文档
     * @param srcTransPath 原翻译文档
     * @param dstTransPath 更新的翻译文档
     * @throws IOException
     */
    public void process(String srcPath, String dstPath, String srcTransPath, String dstTransPath) throws IOException {
        // 1. 读取路径中的所有文件rst和md文件
        List<String> srcFiles = Utils.getFiles(srcPath);
        List<String> dstFiles = Utils.getFiles(dstPath);
        System.out.println("src 总文件数：" + srcFiles.size());
        System.out.println("dst 总文件数：" + dstFiles.size());

        List<String> changedFiles = new ArrayList<>();
        List<String> newFiles = new ArrayList<>();
        List<String> deletedFiles = new ArrayList<>();
        List<String> sameFiles = new ArrayList<>();

        srcFiles = Utils.getRelativePath(srcFiles, srcPath);
        dstFiles = Utils.getRelativePath(dstFiles, dstPath);

        // 2. 对比md文件和rst文件的段落数是否一致，该功能主要对比翻译是否正确
        for (String fileName : srcFiles) {
            if (!dstFiles.contains(fileName)) {
                deletedFiles.add(fileName);
            }
        }

        for (String fileName : dstFiles) {
            Path fullSrcPath = Utils.getFullPath(srcPath, fileName);
            Path fullDstPath = Utils.getFullPath(dstPath, fileName);
            Path fullSrcTransPath = Utils.getFullPath(srcTransPath, fileName);
            Path fullDstTransPath = Utils.getFullPath(dstTransPath, fileName);

            // 创建目录
            if (Files.notExists(fullDstTransPath)) {
//                String temDir = fullDstTransPath.toString().substring(0, fullDstTransPath.toString().lastIndexOf(File.separator));
                Files.createDirectories(fullDstTransPath.getParent());
            }

            // 新增文件直接拷贝英文文档
            if (!srcFiles.contains(fileName)) {
                newFiles.add(fileName);
                Files.copy(fullDstPath, fullDstTransPath, StandardCopyOption.REPLACE_EXISTING);
                continue;
            }

            boolean isSame = compareFiles(fullSrcPath, fullDstPath);
            if (!isSame) {
                changedFiles.add(fileName);
                //TODO 处理更新了的文档
                // 暂时处理方法：将新的英文文档各行插入上个版本的翻译文档
                List<String> srcTransPathContent = Utils.getContentByParagraph(fullSrcTransPath);
                List<String> dstPathContent = Utils.getContentByParagraph(fullDstPath);

                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(fullDstTransPath.toFile()));
                int size = Math.max(srcTransPathContent.size(), dstPathContent.size());
                for (int i = 0; i < size; i++) {
                    String srcContent = "";
                    String dstContent = "";
                    if (i < srcTransPathContent.size()) {
                        srcContent = srcTransPathContent.get(i);
                        bufferedWriter.write(srcContent);
//                        bufferedWriter.write(System.lineSeparator());
//                        bufferedWriter.write(System.lineSeparator());
                    }
                    if (i < dstPathContent.size()) {
                        dstContent = dstPathContent.get(i);
                        if (dstContent.equals(srcContent)) continue; // 不处理未翻译内容
                        bufferedWriter.write(dstContent);
//                        bufferedWriter.write(System.lineSeparator());
//                        bufferedWriter.write(System.lineSeparator());
                    }
                }
                bufferedWriter.flush();
            } else {
                // 没有改动的文档直接拷贝翻译文档
                sameFiles.add(fileName);
                Files.copy(fullSrcTransPath, fullDstTransPath, StandardCopyOption.REPLACE_EXISTING);
            }
        }

        System.out.println("不变文件数：" + sameFiles.size());
        for (String sameFile : sameFiles) {
            System.out.println(sameFile);
        }
        System.out.println("删除文件数：" + deletedFiles.size());
        for (String deletedFile : deletedFiles) {
            System.out.println(deletedFile);
        }
        System.out.println("新增文件数：" + newFiles.size());
        for (String newFile : newFiles) {
            System.out.println(newFile);
        }
        System.out.println("修改文件数：" + changedFiles.size());
        for (String changedFile : changedFiles) {
            System.out.println(changedFile);
        }

        // 3. 对比两个文件的不同，该功能主要对比英文文档的更新内容

        // 4. 将英文文档更新的段落整段放在翻译文档对应的段落之后
    }

    private boolean compareFiles(Path filePath1, Path filePath2) throws IOException {
        List<String> content1 = Utils.getContentByParagraph(filePath1);
        List<String> content2 = Utils.getContentByParagraph(filePath2);
        if (content1.size() != content2.size()) {
            return false;
        }

        // 判断每段内容是否一致
        for (int i = 0; i < content2.size(); i++) {
            if (!content1.get(i).equals(content2.get(i))) {
                return false;
            }
        }

        return true;
    }
}
